home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 7 / FM Towns Free Software Collection 7.iso / t_os / gpen32k / source.exe / SRC / GPEN32K.C < prev    next >
C/C++ Source or Header  |  1993-08-09  |  24KB  |  1,036 lines
  1. /*****************************************************************
  2.         ＴＯＷＮＳ最強のパターンエディタ
  3.             Ｇ－Ｐｅｎ３２ｋ
  4.                             Copyright(C) 1991,1992,1993 Okome
  5. *****************************************************************/
  6.  
  7. #include    <stdio.h>
  8. #include    <io.h>
  9. #include    <stdlib.h>
  10. #include    <string.h>
  11. #include    <math.h>
  12. #include    <fmcfrb.h>
  13. #include    <EGB.H>
  14. #include    <MOS.H>
  15. #include    <sidework.h>
  16. #include    <kkstr2.h>
  17. #include    <normlib.h>
  18. #include    <okome.h>
  19. #define    MAIN
  20. #include    <GPen32k.h>
  21. #undef    MAIN
  22.  
  23. void draw()        /*    画面初期化    */
  24. {
  25.     int i, x, y;
  26.     char c[64] = {    0x00,0x00,    0x10,0x00,    0x00,0x02,    0x10,0x02,
  27.                     0x00,0x40,    0x10,0x40,    0x00,0x42,    0x10,0x42,
  28.                     0x08,0x21,    0x1f,0x00,    0xe0,0x03,    0xff,0x03,
  29.                     0x00,0x7c,    0x1f,0x7c,    0xe0,0x7f,    0xff,0x7f };
  30.     wpg(0);
  31.     EGB_tmenuPalette2( work );
  32. /*    MEN_sidein(2);    */    /*    メニューへのサイドワークの追加 登録のみ    */
  33.     MEN_set(2);
  34.     EGB_textSpace( work, 7 );
  35.     symbol( 589, 17, "大終", 16, 15 );
  36.     EGB_textSpace( work, 0 );
  37.     boxf( 0, 20, 639, 479, BCL );
  38.     KAN_disp(KAN_DISPON);
  39.     KAN_setMode(0x30140);
  40.     wpg(1);
  41.     EGB_displayStart( work, 2, bi, bi );
  42.     EGB_displayStart( work, 3, 640/bi, 480/bi );
  43.     egbputZ( CSX1, CSY1, CSX2, CSY2, 16, 1, c );
  44.     for ( y = 0; y <= 2; y++ )
  45.     {
  46.         for ( i = 0; i < 32; i++ )
  47.         {
  48.             WORD(c+i*2) = i * (1 << ((2 - y) * 5));
  49.         }
  50.         egbputZ(PALX, PALY+y*PALB, PALX+127, PALY+(y+1)*PALB-1, 32, 1, c);
  51.     }
  52.     tcl(1, 0);
  53.     tcl(2, 1);
  54.     wpg(0);
  55.     biboxbf( WX1, WY1, WX2, WY2, 0, 8, 8 );
  56.     biboxbf( BX1, BY1, BX2, BY2, 0, 8, 8 );
  57.     biboxbf( NX1, NY1, NX2, NY2, 0, 4, 4 );
  58.     biboxbf( CSX1, CSY1, CSX2, CSY2, 0, 2, 2 );
  59.     biboxbf( CBX1, CBY1, CBX2, CBY2, 0, 4, 4 );
  60.     biboxbf( CBLX1, CBLY1, CBLX2, CBLY2, 0, 2, 2 );
  61.     biboxbf( CBRX1, CBRY1, CBRX2, CBRY2, 0, 2, 2 );
  62.     ubox( CSBX1, CSBY1, CSBX2, CSBY2, 15, 8 );
  63.     for ( i = 0; i < MEZ0; i++ )
  64.     {
  65.         x = i % MEX2;
  66.         y = i / MEX2;
  67.         ubox( MEX1+MEX4*x, MEY1+MEY4*y,
  68.               MEX1+MEX4*(x+1)-1, MEY1+MEY4*(y+1)-1, 15, 8 );
  69.     }
  70.     symbol( MEX1+5, MEY1+        18, " ～  ／", 16, 14 );
  71.     symbol( MEX1+5, MEY1+MEY4   +18, " □  ■", 16, 14 );
  72.     symbol( MEX1+5, MEY1+MEY4* 2+18, " ○  ●", 16, 14 );
  73.     symbol( MEX1+5, MEY1+MEY4* 3+18, "楕○楕●", 16, 14 );
  74.     symbol( MEX1+5, MEY1+MEY4* 4+18, "↑↓←→", 16, 14 );
  75.     symbol( MEX1+4, MEY1+MEY4* 5+18, "Poly 塗", 16, 14 );
  76.     symbol( MEX1+4, MEY1+MEY4* 6+18, "CopyRoll", 16, 14 );
  77.     symbol( MEX1+4, MEY1+MEY4* 7+18, "ぼけ回転", 16, 14 );
  78.     symbol( MEX1+4, MEY1+MEY4* 8+18, "拡縮反転", 16, 14 );
  79.     symbol( MEX1+5, MEY1+MEY4* 9+18, " ⇔ ⇔重", 16, 15 );
  80.     symbol( MEX1+5, MEY1+MEY4*10+18, " ～ Roll", 16, 15 );
  81.     symbol( MEX1+4, MEY1+MEY4*11+18, "色々もわ", 16, 15 );
  82.     wkugiri(1);
  83.     biboxbf( PALX, PALY, PALX+127, PALY+PALB*3-1, 0, 4, 28 );
  84.     biboxbf( PCX1, PCY1, PCX2, PCY2, 0, 0, 0 );
  85.     biboxbf( PLX1, PLY1, PLX2, PLY2, 0, 0, 0 );
  86.     biboxbf( PRX1, PRY1, PRX2, PRY2, 0, 0, 0 );
  87.     ubox( SPX1, SPY1, SPX2, SPY2, 15, 8 );
  88.     ubox( RX1, RY1, RX2, RY2, 15, 8 );
  89.     symbol( SPX1+5, SPY2-2, "Spoit", 16, 15 );
  90.     symbol( SPX1+4, SPY2-3, "Spoit", 16, 8 );
  91.     ubox( PAX1, PAY1, PAX2, PAY2, 8, 15 );
  92.     ubox( HX1, HY1, HX2, HY2, 8, 15 );
  93.     bfgs(1);
  94.     for (y=0; y<=2; y++)
  95.         mcolms(y);
  96.     wpg(1);
  97.     mbclp();
  98.     page(0);
  99. }
  100.  
  101. int sachk(char *nn)
  102. {
  103.     if (_access(nn,0)==0)
  104.     {
  105.         return (message("上書きしますか？",2));
  106.     }
  107.     return (0);
  108. }
  109.  
  110. void raten( int mb, int cx, int cy, int x1, int y1, int x2, int y2, 
  111.                                     int sx1, int sy1, int sx2, int sy2 )
  112. {
  113.     char pa[64], pab[64];
  114.     int n, ws, a, b2, mx, my, c, d;
  115.     int x, y, x3, y3, x4, y4, x5, y5, x6, y6, x7=0, y7=0, x8, y8;
  116.     double ls, xx, yy, ax, ay;
  117.     view( WX1,WY1, WX2,WY2 );
  118.     egbget(x1,y1,x2,y2, b);
  119.     egbput(640/bi,0, 640/bi+x2-x1,y2-y1, b);
  120.     EGB_writePage( work, 0 );
  121.     EGB_writeMode( work, 4 );
  122.     x3 = x1*bi;    y3 = y1*bi;
  123.     x4 = x2*bi;    y4 = y1*bi;
  124.     x5 = x2*bi;    y5 = y2*bi;
  125.     x6 = x1*bi;    y6 = y2*bi;
  126.     MOS_disp(0);
  127.     connect(5, x3,y3, x4,y3, x4,y4, x3,y4, x3,y3, 0x02, 0x7fff );
  128.     MOS_disp(1);
  129.     cx /= bi;
  130.     cy /= bi;
  131.     mbout( &mb, &mx, &my );
  132.     mbin( &mb, &x8, &y8 );
  133.     do
  134.     {
  135.         MOS_rdpos( &mb, &x, &y );
  136.         if (x7 != x || y7 != y)
  137.         {
  138.             MOS_disp(0);
  139.             connect(5, x3,y3, x4,y4, x5,y5, x6,y6, x3,y3, 0x02, 0x7fff );
  140.             MOS_disp(1);
  141.             ls = atan2(x8-cx*bi, y8-cy*bi) - atan2(x-cx*bi,y-cy*bi);
  142.             xx = x1 - cx;
  143.             ax = x2 - cx;
  144.             yy = y1 - cy;
  145.             ay = y2 - cy;
  146.             x3 = (cx + xx * cos(ls) - yy * sin(ls))*bi;
  147.             y3 = (cy + xx * sin(ls) + yy * cos(ls))*bi;
  148.             x4 = (cx + ax * cos(ls) - yy * sin(ls))*bi;
  149.             y4 = (cy + ax * sin(ls) + yy * cos(ls))*bi;
  150.             x5 = (cx + ax * cos(ls) - ay * sin(ls))*bi;
  151.             y5 = (cy + ax * sin(ls) + ay * cos(ls))*bi;
  152.             x6 = (cx + xx * cos(ls) - ay * sin(ls))*bi;
  153.             y6 = (cy + xx * sin(ls) + ay * cos(ls))*bi;
  154.             MOS_disp(0);
  155.             connect(5, x3,y3, x4,y4, x5,y5, x6,y6, x3,y3, 0x02, 0x7fff );
  156.             MOS_disp(1);
  157.             x7 = x;
  158.             y7 = y;
  159.         }
  160.     }    while (mb);
  161.     MOS_disp(0);
  162.     connect(5, x3,y3, x4,y4, x5,y5, x6,y6, x3,y3, 0x02, 0x7fff );
  163.     MOS_disp(1);
  164.     EGB_writeMode( work, 0 );
  165.     EGB_writePage( work, 1 );
  166.     WORD(pa) = 4;
  167.     WORD(pa+2) = sx1;
  168.     WORD(pa+4) = sy1;
  169.     WORD(pa+6) = sx2;
  170.     WORD(pa+8) = sy1;
  171.     WORD(pa+10) = sx2;
  172.     WORD(pa+12) = sy2;
  173.     WORD(pa+14) = sx1;
  174.     WORD(pa+16) = sy2;
  175.     EGB_region( work, &n, &ws, &a, &b2, &c, &d, pa );
  176.     pab[0] = 1;
  177.     pab[1] = 0;
  178.     WORD(pab+2) = (cx-x1)/KS+sx1;
  179.     WORD(pab+4) = (cy-y1)/KS+sy1;
  180.     ls *= 180.0 / _PI;
  181.     if (ls<0)
  182.         ls+=360.0;
  183.     if (ls>=360.0)
  184.         ls-=360.0;
  185.     WORD(pab+6) = (int)ls;
  186.     EGB_rotate( work, 0, pab, b );
  187.     wkk();
  188. }
  189.  
  190. void ten(int x, int y, int h)
  191. {
  192.     int i;
  193.     egbget(x,y,x+h-1,y+h-1, b);
  194.     for ( i=0; i<h; i++ )
  195.     {
  196.         egbput(x+i,y,x+i,y+h-1, &b[h*(h-i-1)*2]);
  197.     }
  198. }
  199.  
  200. void mspoit( void )
  201. {
  202.     int mb, mx, my;
  203.     MOS_disp( 0 );
  204.     MOS_typeRom2( 86, 1, 1, mpat );
  205.     MOS_disp( 1 );
  206.     mbout( &mb, &mx, &my );
  207.     do    {
  208.         MOS_rdpos( &mb, &mx, &my );
  209.     }    while (mb==0);
  210.     MOS_disp( 0 );
  211.     MOS_typeRom2( 81, 1, 1, mpat );
  212.     MOS_disp( 1 );
  213.     tclc(mb, mx, my);
  214.     mbout( &mb, &mx, &my );
  215. }
  216.  
  217. void gmenu( int mx, int my )        /*    アイコンMENU    */
  218. {
  219.     int x, y, i, j;
  220.     
  221.     i = (( mx - MEX1 ) / MEX4) + MEX2 * (( my - MEY1 ) / MEY4);
  222.     if ( i<MEZ1 )    {
  223.         j = 0;
  224.     }    else    {
  225.         j = 1;
  226.     }
  227.     x = MEX1 +((mei[j] + j * MEZ1) % MEX2)* MEX4;
  228.     y = MEY1 + (mei[j] + j * MEZ1) / MEX2 * MEY4;
  229.     mei[j] = i - j * MEZ1;
  230.     mx = MEX1 +(i % MEX2)* MEX4;
  231.     my = MEY1 + i / MEX2 * MEY4;
  232.     wpg(0);
  233.     ubox(  x,  y,  x+MEX4-1,  y+MEY4-1, 15, 8 );
  234.     ubox( mx, my, mx+MEX4-1, my+MEY4-1, 8, 15 );
  235.     wpg(1);
  236. }
  237.  
  238. void mcolm( int mb, int mx, int my )        /*    カラー選択バー    */
  239. {
  240.     int i, j, c;
  241.     j = ( my - PALY*bi ) / ( PALB*bi );
  242.     i = ( 1 << ((2-j)*5) );
  243.     umosv(PALX, PALY+PALB*j, PALX+127, PALY+PALB*(j+1)-1 );
  244.     while (mb!=0)
  245.     {
  246.         MOS_rdpos( &mb, &mx, &my );
  247.         c = (mx - PALX*bi) / 8;
  248.         mcols((mcl[0] & (0xffff - 0x1f * i)) + c * i);
  249.     }
  250.     mosv(0, 0, 639, 479);
  251. }
  252.  
  253. void mcolm2( int mb )
  254. {
  255.     mcl[mb] = mcl[0];
  256.     mbclp();
  257. }
  258.  
  259. void rollsub( int x3, int y3, int X1, int Y1, int X3, int Y3 )
  260. {
  261.     int X2, Y2, Y4;
  262.     X2 = X1+X3;
  263.     Y2 = Y1+Y3;
  264.     Y4 = Y3+1;
  265.     egbget( X1, Y1, X1+(x3-1 & X3), Y2, b );
  266.     egbget( X1+x3, Y1, X2, Y2, &(b[x3*Y4*2]) );
  267.     egbput( X2-(x3-1 & X3), Y2-(y3-1 & Y3), X2, Y2, b );
  268.     egbput( X2-(x3-1 & X3), Y1, X2, Y2-y3, &(b[x3*y3*2]) );
  269.     egbput( X1, Y2-(y3-1 & Y3), X2-x3, Y2, &(b[x3*Y4*2]) );
  270.     egbput( X1, Y1, X2-x3, Y2-y3, &(b[(x3*Y4+(X3-x3+1)*y3)*2]) );
  271. }
  272.  
  273. void rollsander( int mb, int mx, int my )
  274. {
  275.     int x2, y2, x3, y3;
  276.     mx = wnx(mx);
  277.     my = wny(my);
  278.     do
  279.     {
  280.         MOS_rdpos( &mb, &x2, &y2 );
  281.         x3 = mx - wnx(x2) & NX3;
  282.         y3 = my - wny(y2) & NY3;
  283.         rollsub( x3, y3, NX1, NY1, NX3, NY3 );
  284.         wkk();
  285.         mx = wnx(x2);
  286.         my = wny(y2);
  287.     }    while (mb);
  288. }
  289.  
  290. void tometen(int x1, int y1, int x2, int y2)
  291. {
  292.     int x, y, mb;
  293.     wpg(0);
  294.     for (y = y1; y<=y2; y++)
  295.     {
  296.         EGB_writePage(work,1);
  297.         egbget(x1,y,x2,y,b);
  298.         EGB_writePage(work,0);
  299.         for (x = x1; x<=x2; x++)
  300.         {
  301.             if ((WORD(b+(x-x1)*2) & 0x8000)!=0)
  302.             {
  303.                 line(x*bi,y*bi,(x+1)*bi-1,(y+1)*bi-1,15);
  304.                 line((x+1)*bi-1,y*bi,x*bi,(y+1)*bi-1,8);
  305.             }
  306.         }
  307.     }
  308.     MOS_typeRom2( 76, 8, 8, mpat );
  309.     wpg(1);
  310.     mbin(&mb,&x,&y);
  311.     mbout(&mb,&x,&y);
  312.     wpg(0);
  313.     boxf(x1*bi,y1*bi,(x2+1)*bi-1,(y2+1)*bi-1,0);
  314.     MOS_typeRom2( 81, 1, 1, mpat );
  315.     wpg(1);
  316. }
  317.  
  318. /*    編集窓用機能軍    */
  319.  
  320. void mpaint( int mb, int mx, int my )
  321. {
  322.     char pa[4];
  323.     EGB_paintMode( work, 0x22 );
  324.     EGB_color( work, 2, mcl[mb] );
  325.     WORD(pa) = wnx(mx);
  326.     WORD(pa+2) = wny(my);
  327.     EGB_closePaint( work, pa );
  328.     wkk();
  329. }
  330.  
  331. void mdr( int mb, int mx, int my )    /*    編集窓描画    */
  332. {
  333.     int mx2, my2, x, y, x2, y2;
  334.     mx2 = mx;
  335.     my2 = my;
  336.     while (mb != 0 && mx/bi >= WX1 && mx/bi <= WX2 &&
  337.                       my/bi >= WY1 && my/bi <= WY2 )
  338.     {
  339.         line( wnx(mx2), wny(my2), wnx(mx), wny(my), mcl[mb] );
  340.         x = wnx(mx);
  341.         x2 = wnx(mx2);
  342.         bsz( &x, &x2 );
  343.         y = wny(my);
  344.         y2 = wny(my2);
  345.         bsz( &y, &y2 );
  346.         egbget( x, y, x2, y2, b );
  347.         egbputZ( WX1+(x-NX1)*KS, WY1+(y-NY1)*KS,
  348.                  WX1+(x2-NX1+1)*KS-1, WY1+(y2-NY1+1)*KS-1,
  349.                  x2-x+1, y2-y+1, b );
  350.         mx2 = mx;
  351.         my2 = my;
  352.         MOS_rdpos( &mb, &mx, &my );
  353.     }
  354. }
  355.  
  356. void mwwp( int *mb, int *mx, int *my, int *x, int *y, void (*vfp)(), int f )
  357. {
  358.     int x2, y2, b2;
  359.     view( WX1,WY1, WX2,WY2 );
  360.     umosv( WX1,WY1, WX2,WY2 );
  361.     EGB_writeMode( work, 4 );
  362.     *mx = wcx(*mx);
  363.     *my = wcy(*my);
  364.     vfp( *mx, *my, *mx, *my, 0x7fff );
  365.     x2 = *mx;
  366.     y2 = *my;
  367.     do
  368.     {
  369.         b2 = *mb;
  370.         MOS_rdpos( mb, x, y );
  371.         *x = wcx(*x);
  372.         *y = wcy(*y);
  373.         if (*x != x2 || *y != y2 )
  374.         {
  375.             vfp( *mx, *my, x2, y2, 0x7fff );
  376.             vfp( *mx, *my, *x, *y, 0x7fff );
  377.         }
  378.         x2 = *x;
  379.         y2 = *y;
  380.     }    while (*mb);
  381.     if (f==0)
  382.         vfp( *mx, *my, x2, y2, 0x7fff );
  383.     *mb = b2;
  384. }
  385.  
  386. void mline( int mb, int mx, int my, void (*vic)() )
  387. {
  388.     int x, y;
  389.     mwwp( &mb, &mx, &my, &x, &y, vic, 1 );
  390.     view( NX1,NY1, NX2,NY2 );
  391.     EGB_writeMode( work, 0 );
  392.     vic( nbx(mx), nby(my), nbx(x), nby(y), mcl[mb] );
  393.     wkk();
  394. }
  395.  
  396. void mcpyl( int mb, int mx, int my, int c )
  397. {
  398.     int x, y, x2, y2, x3, y3;
  399.     mwwp( &mb, &mx,&my, &x,&y, boxb, 0 );
  400.     bsz( &mx, &x );
  401.     bsz( &my, &y );
  402.     egbget( nbx(mx),nby(my), nbx(x),nby(y), b );
  403.     boxb( mx, my, x, y, 0x7fff );
  404.     mbin( &mb, &x3, &y3 );
  405.     if (mb == 1)
  406.     {
  407.         if (c)
  408.         {
  409.             EGB_writeMode( work, 0 );
  410.             boxf(wnx(mx),wny(my), wnx(x), wny(y), mcl[2] );
  411.             EGB_writeMode( work, 4 );
  412.         }
  413.         x3 = wcx(x3);
  414.         y3 = wcy(y3);
  415.         mx -= x3;
  416.         my -= y3;
  417.         x -= x3;
  418.         y -= y3;
  419.         do
  420.         {
  421.             MOS_rdpos( &mb, &x2, &y2 );
  422.             x2 = wcx(x2);
  423.             y2 = wcy(y2);
  424.             while ( x2+x > WX2 )
  425.                 x2-=KS;
  426.             while ( y2+y > WY2 )
  427.                 y2-=KS;
  428.             while ( x2+mx < WX1 )
  429.                 x2+=KS;
  430.             while ( y2+my < WY1 )
  431.                 y2+=KS;
  432.             if (x3 != x2 || y3 != y2 )
  433.             {
  434.                 boxb( x3+mx,y3+my, x3+x,y3+y, 0x7fff );
  435.                 boxb( x2+mx,y2+my, x2+x,y2+y, 0x7fff );
  436.             }
  437.             x3 = x2;
  438.             y3 = y2;
  439.         }    while (mb);
  440.         view( NX1,NY1, NX2,NY2 );
  441.         EGB_writeMode( work, 0 );
  442.         egbput( nbx(x3+mx),nby(y3+my), nbx(x3+x),nby(y3+y), b );
  443.     }
  444.     EGB_writeMode( work, 0 );
  445.     wkk();
  446. }
  447.  
  448. void boke(int mx, int my, int x, int y)
  449. {
  450.     int n=0x80, si, x1, y1, x2, y2;
  451.     char pa[64];
  452.     WORD(pa+0)=4;
  453.     WORD(pa+2)=mx;
  454.     WORD(pa+4)=my;
  455.     WORD(pa+6)=x;
  456.     WORD(pa+8)=my;
  457.     WORD(pa+10)=x;
  458.     WORD(pa+12)=y;
  459.     WORD(pa+14)=mx;
  460.     WORD(pa+16)=y;
  461.     EGB_region( work, &n, &si, &x1,&y1, &x2,&y2, pa );
  462.     EGB_resolve(work,b);
  463. }
  464.  
  465. void hten(int x, int y, int x2, int y2)
  466. {
  467.     EGB_writeMode( work, 4 );
  468.     boxf( x,y, x2,y2, 0x7fff );
  469.     EGB_writeMode( work, 0 );
  470. }
  471.  
  472. void tens(int mb, int mx, int my, void (*vic)())
  473. {
  474.     int x, y;
  475.     mwwp( &mb, &mx,&my, &x,&y, boxb, 0 );
  476.     EGB_writeMode( work, 0 );
  477.     view(NX1,NY1,NX2,NY2);
  478.     mx = nbx(mx);
  479.     my = nby(my);
  480.     x = nbx(x);
  481.     y = nby(y);
  482.     vic(mx,my,x,y);
  483.     wkk();
  484. }
  485.  
  486. void kakshk(int mb, int mx, int my)
  487. {
  488.     int x, y, x2, y2, ox, oy, ox2, oy2;
  489.     ox = mx;
  490.     oy = my;
  491.     mwwp( &mb, &ox,&oy, &ox2,&oy2, boxb, 0 );
  492.     egbget( nbx(ox),nby(oy), nbx(ox2),nby(oy2), b );
  493.     boxb(ox,oy,ox2,oy2,0x7fff);
  494.     x2 = abs(nbx(ox2)-nbx(ox))+1;
  495.     y2 = abs(nby(oy2)-nby(oy))+1;
  496.     mbin(&mb,&mx,&my);
  497.     mwwp( &mb, &mx,&my, &x,&y, boxb, 0 );
  498.     boxb(ox,oy,ox2,oy2,0x7fff);
  499.     EGB_writeMode(work,0);
  500.     egbputZ( nbx(mx),nby(my), nbx(x),nby(y), x2,y2, b );
  501.     wkk();
  502. }
  503.  
  504. void polyg( int mb, int mx, int my )
  505. {
  506.     int i=6, x, y, ox, oy;
  507.     view( WX1,WY1, WX2,WY2 );
  508.     umosv( WX1,WY1, WX2,WY2 );
  509.     ox = mx;
  510.     oy = my;
  511.     WORD(b+2) = wnx(mx);
  512.     WORD(b+4) = wny(my);
  513.     EGB_writeMode(work,4);
  514.     line( wcx(mx),wcy(my), wcx(mx),wcy(my), 0x7fff );
  515.     while(mb!=2 && i<1020)
  516.     {
  517.         do
  518.         {
  519.             x = mx;
  520.             y = my;
  521.             MOS_rdpos(&mb,&mx,&my);
  522.             line( wcx(ox),wcy(oy), wcx(x),wcy(y), 0x7fff );
  523.             line( wcx(ox),wcy(oy), wcx(mx),wcy(my), 0x7fff );
  524.         }    while(mb==0 || (mb==1 && wcx(ox)==wcx(mx) && wcy(oy)==wcy(my)));
  525.         ox = mx;
  526.         oy = my;
  527.         WORD(b+i)   = wnx(mx);
  528.         WORD(b+i+2) = wny(my);
  529.         i+=4;
  530.     }
  531.     EGB_writeMode(work,0);
  532.     WORD(b)=(i-2)/4;
  533.     view( NX1,NY1, NX2,NY2 );
  534.     EGB_paintMode(work, 0x22);
  535.     EGB_color(work, 0, mcl[1]);
  536.     EGB_color(work, 2, mcl[1]);
  537.     EGB_polygon( work, b );
  538.     wkk();
  539.     mbout(&mb,&mx,&my);
  540. }
  541.  
  542. void mnw( int mb, int mx, int my )        /*    編集窓    */
  543. {
  544.     view( NX1, NY1, NX2, NY2 );
  545.     switch(mei[0])
  546.     {
  547.     case 1:    mline( mb, mx, my, line );        break;
  548.     case 2:    mline( mb, mx, my, boxb );        break;
  549.     case 3:    mline( mb, mx, my, boxf );        break;
  550.     case 4:    mline( mb, mx, my, circlen2 );    break;
  551.     case 5:    mline( mb, mx, my, circlef2 );    break;
  552.     case 6:    mline( mb, mx, my, circlenl );    break;
  553.     case 7:    mline( mb, mx, my, circlefl );    break;
  554.     case 8:    tens(mb, mx, my, udten);        break;
  555.     case 9:    tens(mb, mx, my, lrten);        break;
  556.     case 10: polyg( mb, mx, my );            break;
  557.     case 11: mpaint( mb, mx, my );            break;
  558.     case 12: mcpyl( mb, mx, my, 0 );        break;
  559.     case 13: rollsander( mb, mx, my );        break;
  560.     case 14: tens( mb, mx, my, boke );        break;
  561.     case 15: raten( mb, mx, my, WX1, WY1, WX2, WY2, NX1, NY1, NX2, NY2 );
  562.         break;
  563.     case 16: kakshk( mb, mx, my );            break;
  564.     case 17: tens( mb, mx, my, hten );        break;
  565.     default: mdr( mb, mx, my );                break;
  566.     }
  567.     mosv( 0,0, 639,479 );
  568.     view( 0, 0, 1024/bi-1, 512/bi-1 );
  569. }
  570.  
  571. int gpx(int mx)
  572. {
  573.     int mx2;
  574.     mx2 = BX1 + ( mx/bi - NX4/2 + ix/2 - BX1 ) / ix * ix;
  575.     if ( mx2 < BX1 )    mx2 = BX1;
  576.     if ( mx2 + NX3 > BX2 )    mx2 = BX2 - NX3;
  577.     return (mx2);
  578. }
  579.  
  580. int gpy(int my)
  581. {
  582.     int my2;
  583.     my2 = BY1 + ( my/bi - NY4/2 + iy/2 - BY1 ) / iy * iy;
  584.     if ( my2 < BY1 )    my2 = BY1;
  585.     if ( my2 + NY3 > BY2 )    my2 = BY2 - NY3;
  586.     return (my2);
  587. }
  588.  
  589. void mbwk( int mx, int my, int c )    /*    バッファセット用枠    */
  590. {
  591.     static int x = 0, y = 512, c2 = 0;
  592.     int mx2, my2;
  593.     if ( mx/bi < BX1 || mx/bi > BX2 || my/bi < BY1 || my/bi > BY2 )
  594.     {
  595.         c = 0;
  596.     }
  597.     if ( c == 0 )
  598.     {
  599.         if ( c2 != 0 )
  600.         {
  601.             wpg(0);
  602.             boxb( x, y, x+NX4*bi-1, y+NY4*bi-1, 0 );
  603.             wpg(1);
  604.             y = 512;
  605.         }
  606.     }    else    {
  607.         mx2 = gpx(mx)*bi;
  608.         my2 = gpy(my)*bi;
  609.         if ( x != mx2 || y != my2 || c2 == 0 )
  610.         {
  611.             wpg(0);
  612.             boxb( x, y, x+NX4*bi-1, y+NY4*bi-1, 0 );
  613.             boxb( mx2, my2, mx2+NX4*bi-1, my2+NY4*bi-1, 15 );
  614.             wpg(1);
  615.             x = mx2;
  616.             y = my2;
  617.         }
  618.     }
  619.     c2 = c;
  620. }
  621.  
  622. void bfgp( int mb, int mx, int my )        /*    バッファ編集窓間複写    */
  623. {
  624.     int mx2, my2;
  625.     mx2 = gpx(mx);
  626.     my2 = gpy(my);
  627.     if (mb == 1)
  628.     {
  629.         wget();
  630.         egbput(mx2, my2, mx2+NX3, my2+NY3, wb );
  631.     }    else    {
  632.         egbget(mx2, my2, mx2+NX3, my2+NY3, wb );
  633.         wput();
  634.     }
  635. }
  636.  
  637. void bfsrgp( int mb, int mx, int my )    /*    重ね合わせ    */
  638. {
  639.     int mx2, my2;
  640.     mx2 = gpx(mx);
  641.     my2 = gpy(my);
  642.     if (mb == 1)
  643.     {
  644.         wget();
  645.         egbput(mx2, my2, mx2+NX3, my2+NY3, wb );
  646.     }    else    {
  647.         egbget( NX1, NY1, NX2, NY2, b );
  648.         egbget(mx2, my2, mx2+NX3, my2+NY3, wb );
  649.         egbput( 320, 0, 320+NX3, NY3, wb );
  650.         EGB_color( work, 3, mcl[2] );
  651.         EGB_writeMode( work, 6 );
  652.         egbput( 320, 0, 320+NX3, NY3, b );
  653.         EGB_writeMode( work, 0 );
  654.         egbget( 320, 0, 320+NX3, NY3, wb );
  655.         wput();
  656.     }
  657. }
  658.  
  659. void bfdraw( int mb, int mx, int my )
  660. {
  661.     int mx2, my2;
  662.     mx2 = mx;
  663.     my2 = my;
  664.     while (mb != 0)    {
  665.         if (mx2/bi >= BX1 && mx2/bi <= BX2 &&
  666.             my2/bi >= BY1 && my2/bi <= BY2 )    {
  667.             line( mx2/bi, my2/bi, mx/bi, my/bi, mcl[mb] );
  668.         }    else    {
  669.             break;
  670.         }
  671.         mx2 = mx;
  672.         my2 = my;
  673.         MOS_rdpos( &mb, &mx, &my );
  674.     }
  675. }
  676.  
  677. void cols16(int mb, int mx, int my)
  678. {
  679.     int i;
  680.     if (mb==1)
  681.     {
  682.         i=(mx-CSX1)/CSX4;
  683.         boxf(CSX1+i*CSX4,CSY1,CSX1+i*CSX4+CSX3,CSY2,mcl[1]);
  684.     }    else    {
  685.         egbget(mx,my,mx,my,b);
  686.         mcl[1] = WORD(b);
  687.         mbclp();
  688.     }
  689. }
  690.  
  691. void cols16g(int mb)
  692. {
  693.     int f, i, j, k=0;
  694.     egbget(NX1,NY1,NX2,NY2,b);
  695.     for ( i=0; i<16; i++ )
  696.     {
  697.         WORD(b+32768+i*2) = 0;
  698.     }
  699.     for (i = 0; i < NX4*NY4*2; i+=2)
  700.     {
  701.         f = 0;
  702.         for (j=0; j<k; j++)
  703.         {
  704.             if (WORD(b+32768+j*2)==WORD(b+i))
  705.             {
  706.                 f = 1;
  707.                 break;
  708.             }
  709.         }
  710.         if (f==0)
  711.         {
  712.             WORD(b+32768+k*2) = WORD(b+i);
  713.             k++;
  714.         }
  715.         if (k>15)
  716.             break;
  717.     }
  718.     egbget(CSX1, CSY1, CSX2-CSX4*k, CSY2, b+65536);
  719.     egbput(CSX1+CSX4*k, CSY1, CSX2, CSY2, b+65536);
  720.     egbputZ(CSX1, CSY1, CSX1+CSX4*k-1, CSY2, k,1, b+32768);
  721.     mbout(&mb,&i,&j);
  722. }
  723.  
  724. void brolls( int mb, int mx, int my )
  725. {
  726.     int x2, y2, x3, y3;
  727.     mx= mx/bi;
  728.     my = my/bi;
  729.     do
  730.     {
  731.         MOS_rdpos( &mb, &x2, &y2 );
  732.         x3 = mx - x2/bi & BX3;
  733.         y3 = my - y2/bi & BY3;
  734.         rollsub( x3, y3, BX1, BY1, BX3, BY3 );
  735.         mx = x2/bi;
  736.         my = y2/bi;
  737.     }    while (mb);
  738. }
  739.  
  740. void colch(int mb, int mx, int my)
  741. {
  742.     egbget( BX1,BY1, BX2,BY2, b );
  743.     boxf( BX1,BY1, BX2,BY2, mcl[1] );
  744.     EGB_writeMode(work,6);
  745.     EGB_color(work,3,mcl[2]);
  746.     egbput( BX1,BY1, BX2,BY2, b );
  747.     EGB_writeMode(work,0);
  748.     mbout(&mb, &mx, &my);
  749. }
  750.  
  751. void pastgo(int mb, int mx, int my)
  752. {
  753.     int mx2, my2;
  754.     mx2 = gpx(mx);
  755.     my2 = gpy(my);
  756.     if (mb == 1)
  757.     {
  758.         wget();
  759.         egbput(mx2, my2, mx2+NX3, my2+NY3, wb );
  760.     }    else    {
  761.         egbget(mx2, my2, mx2+NX3, my2+NY3, wb );
  762.         EGB_writeMode( work, 7 );
  763.         egbput( NX1, NY1, NX2, NY2, wb );
  764.         EGB_writeMode( work, 0 );
  765.         wkk();
  766.         mbout(&mb,&mx,&my);
  767.     }
  768. }
  769.  
  770. void mbuff( int mb, int mx, int my )        /*    バッファ    */
  771. {
  772.     view( BX1, BY1, BX2, BY2 );
  773.     switch (mei[1])
  774.     {
  775.     case 1:        bfsrgp( mb, mx, my );    break;
  776.     case 2:        bfdraw( mb, mx, my );    break;
  777.     case 3:        brolls( mb, mx, my );    break;
  778.     case 4:        colch( mb, mx, my );    break;
  779.     case 5:        pastgo( mb, mx, my );    break;
  780.     default:    bfgp( mb, mx, my );        break;
  781.     }
  782.     view( 0, 0, 1024/bi-1, 512/bi-1 );
  783. }
  784.  
  785. void mouse()        /*    マウス総合領域    */
  786. {
  787.     int mb, mx, my, mx2, my2;
  788.     unsigned int kb, en;
  789.     static char nn[FILENAME_MAX];
  790.     while(1)
  791.     {
  792.         MOS_rdpos( &mb, &mx, &my );
  793.         mx2 = mx / bi;
  794.         my2 = my / bi;
  795.         if ( mei[1] == 2 || mei[1] == 3 )    {
  796.             mbwk( mx, my, 0 );
  797.         }    else    {
  798.             mbwk( mx, my, 1 );
  799.         }
  800.         do    {
  801.             kb = KYB_read(1,&en);
  802.         }    while (kb==0xffff && KAN_inpchk()==KAN_MISET);
  803.         switch(kb)
  804.         {
  805.         case 0x9:
  806.             page(-1);
  807.             break;
  808.         case 0x1b:
  809.             page(1);
  810.             break;
  811.         default:
  812.             break;
  813.         }
  814.         if (mb)    {
  815.             if ( mx2 >= WX1 && mx2 <= WX2 &&
  816.                  my2 >= WY1 && my2 <= WY2 )        {
  817.                 mnw( mb, mx, my );    /*    編集窓    */
  818.             }
  819.             if ( mx2 >= BX1 && mx2 <= BX2 &&
  820.                  my2 >= BY1 && my2 <= BY2 )        {
  821.                 mbuff( mb, mx, my );    /*    バッファ    */
  822.             }
  823.             if ( mx >= MEX1 && my >= MEY1 && mx < MEX1 + MEX4 * MEX2 &&
  824.              MEZ0 > (( mx - MEX1 ) / MEX4) + MEX2 * (( my - MEY1 ) / MEY4 ))
  825.             {
  826.                 gmenu( mx, my );    /*    編集メニュー    */
  827.             }
  828.             if ( my2 >= PALY && my2 < (PALY+PALB*3) &&
  829.                  mx2 >= PALX && mx2 <= PALX + 127)    {
  830.                 mcolm( mb, mx, my );    /*    カラーボックス    */
  831.             }
  832.             if ( mx2 >= PCX1 && mx2 <= PCX2 && 
  833.                  my2 >= PCY1 && my2 <= PCY2 )    {
  834.                 mcolm2( mb );    /*    ボタンへ色セット    */
  835.             }
  836.             if ( mx2 >= PRX1 && mx2 <= PRX2 &&
  837.                  my2 >= PRY1 && my2 <= PRY2 )    {
  838.                 mcols( mcl[2-bc] );
  839.             }
  840.             if ( mx2 >= PLX1 && mx2 <= PLX2 &&
  841.                  my2 >= PLY1 && my2 <= PLY2 )    {
  842.                 mcols( mcl[1+bc] );
  843.             }
  844.             if ( mx >= PAX1 && mx <= PAX2 &&
  845.                  my >= PAY1 && my <= PAY2 )    {
  846.                 pbtn( mb );        /*    ページ変更    */
  847.             }
  848.             if ( mx >= SPX1 && mx <= SPX2 &&
  849.                  my >= SPY1 && my <= SPY2 )    {
  850.                 mspoit();
  851.             }
  852.             if ( mx2 >= CBX1 && mx2 <= CBX2 &&
  853.                  my2 >= CBY1 && my2 <= CBY2 )    {
  854.                 tclc(mb, mx, my);
  855.             }
  856.             if ( mx2 >= CBLX1 && mx2 <= CBLX2 &&
  857.                  my2 >= CBLY1 && my2 <= CBLY2 )    {
  858.                 tcl(mb, 0);
  859.             }
  860.             if ( mx2 >= CBRX1 && mx2 <= CBRX2 &&
  861.                  my2 >= CBRY1 && my2 <= CBRY2 )    {
  862.                 tcl(mb, 1);
  863.             }
  864.             if ( mx2 >= NX1 && mx2 <= NX2 &&
  865.                  my2 >= NY1 && my2 <= NY2 && NX4!=128 )    {
  866.                 wsize(0);
  867.             }
  868.             if ( mx >= HX1 && mx <= HX2 &&
  869.                  my >= HY1 && my <= HY2 )    {
  870.                 bfgs(mb);
  871.             }
  872.             if ( mx >= RX1 && mx <= RX2 &&
  873.                  my >= RY1 && my <= RY2 )    {
  874.                 rchc();
  875.             }
  876.             if ( mx2 >= CSX1 && mx2 <= CSX2 &&
  877.                  my2 >= CSY1 && my2 <= CSY2 )    {
  878.                 cols16(mb, mx2, my2);
  879.             }
  880.             if ( mx >= CSBX1 && mx <= CSBX2 &&
  881.                  my >= CSBY1 && my <= CSBY2 )    {
  882.                 cols16g(mb);
  883.             }
  884.             if ( my < 20 )
  885.             {
  886.                 switch(MEN_menu( mb, mx, my ))
  887.                 {
  888.                 case 1:
  889.                     message("Ｇ-Ｐｅｎ３２ｋ    ver.1.000",1);
  890.                     break;
  891.                 case 4:
  892.                     sdk_invoke();
  893.                     break;
  894.                 case 101:
  895.                     if (OKM_fsel( nn, "TIFFload", 0 ) == 0)
  896.                         tiffload(nn, BX1, BY1);
  897.                     break;
  898.                 case 102:
  899.                     if (OKM_fsel( nn, "TIFFsave", 0 ) == 0)
  900.                         if (sachk(nn) == 0)
  901.                             tiffsave(nn, BX1, BY1, BX2, BY2, 0, 0);
  902.                     break;
  903.                 case 103:
  904.                     if (OKM_fsel( nn, "TIFFsave圧縮", 0 ) == 0)
  905.                         if (sachk(nn) == 0)
  906.                         {
  907.                             MOS_typeRom2(82,16,16,mpat);
  908.                             tiffsave(nn, BX1, BY1, BX2, BY2, 1, 0);
  909.                             MOS_typeRom2(81,0,0,mpat);
  910.                         }
  911.                     break;
  912.                 case 104:
  913.                     if (OKM_fsel( nn, "SPRITEload", 0 ) == 0)
  914.                         sprload( nn, BX1, BY1 );
  915.                     break;
  916.                 case 105:
  917.                     if (OKM_fsel( nn, "SPRITEsave", 0 ) == 0)
  918.                         if (sachk(nn) == 0)
  919.                             sprsave( nn, BX1, BY1 );
  920.                     break;
  921.                 case 106:
  922.                     if (OKM_fsel( nn, "PATTERN4load", 0 ) == 0)
  923.                         ptnload4pg( nn, NX4,NY4 );
  924.                     break;
  925.                 case 107:
  926.                     if (OKM_fsel( nn, "PATTERN4save", 0 ) == 0)
  927.                         if (sachk(nn) == 0)
  928.                             ptnsave4pg( nn, NX4,NY4 );
  929.                     break;
  930.                 case 201:
  931.                     wpg(0);
  932.                     wkugiri(3);
  933.                     wpg(1);
  934.                     break;
  935.                 case 202:
  936.                     wpg(0);
  937.                     wkugiri(2);
  938.                     wpg(1);
  939.                     break;
  940.                 case 203:
  941.                     ten(NX1,NY1,NX4);
  942.                     wkk();
  943.                     break;
  944.                 case 204:
  945.                     ten(BX1,BY1,BX4);
  946.                     break;
  947.                 case 205:
  948.                     tometen(BX1,BY1,BX2,BY2);
  949.                     break;
  950.                 case 206:
  951.                     EGB_writeMode( work, 10 );
  952.                     boxf(BX1-1, BY1-1, BX2+1, BY2+1,0x8000);
  953.                     EGB_writeMode( work, 0 );
  954.                     break;
  955.                 case 207:
  956.                     EGB_writeMode( work, 11 );
  957.                     boxf(BX1-1, BY1-1, BX2+1, BY2+1,0x8000);
  958.                     EGB_writeMode( work, 0 );
  959.                     break;
  960.                 case 9998:
  961.                     wsize(1);
  962.                     break;
  963.                 case 5:
  964.                 case 9999:
  965.                     if(message("G-Pen32kを終了します",2)==0)
  966.                         end();
  967.                     break;
  968.                 default:
  969.                     break;
  970.                 }
  971.             }
  972.         }
  973.     }
  974. }
  975.  
  976. void kkpos( int *x, int *y)
  977. {
  978.     *x = kkx;
  979.     *y = kky;
  980. }
  981.  
  982. void kkinit(void)
  983. {
  984.     static char *kaw;
  985.     int col[16] = {
  986.             0x08,    0x01,    0x02,    0x03,
  987.             0x04,    0x05,    0x06,    0x0f,
  988.             0x00,    0x09,    0x0a,    0x0b,
  989.             0x0c,    0x0d,    0x0e,    0x0f,
  990.         };
  991.     KANJ kk;
  992.     kk.scrn = KAN_SCRN16;
  993.     kk.egbw = work;
  994.     kk.wPage = 0;
  995.     kk.gets = 0;
  996.     kk.getPos = kkpos;
  997.     kk.mosAp = KAN_MOSON;
  998.     kk.maxX = 639;
  999.     kk.maxY = 479;
  1000.     KAN_prepare(&kk);
  1001.     kaw = malloc( KAN_getWorkSize() );
  1002.     KAN_setWorkAdd(0x14,kaw);
  1003.     KAN_setClrTbl(col);
  1004. }
  1005.  
  1006. _mwset_up_args()    { return 0; }    /*    argc argvを使わない    */
  1007.  
  1008. void main()
  1009. {
  1010.     /*    初期化    */
  1011.     EGB_init( work, EgbWorkSize );
  1012.     EGB_resolution( work, 0, GM0 );
  1013.     EGB_resolution( work, 1, GM1 );
  1014.     MOS_start( mwork, MosWorkSize );
  1015.     MOS_writePage( 0 );
  1016.     mosv( 0, 0, 639, 479 );
  1017.     MOS_typeRom2( 81, 1, 1, mpat );
  1018.     KYB_init();
  1019.     KYB_clic( 1 );
  1020.     KYB_setcode( 0x0200);
  1021.     kkinit();
  1022.     NX1 = nx[3];
  1023.     NY1 = ny[3];
  1024.     NX4 = 64/bi;
  1025.     NY4 = NX4;
  1026.     wb = &wallb[672];
  1027.     mcl[1] = 0x7fff;
  1028.     for (vz=2000; vp0 == NULL; vz--)
  1029.     {
  1030.         vp0 = (char *)calloc( (vz+1)*BX4*BY4*Cb/8, 1 );
  1031.     }
  1032.     vp = vp0;
  1033.     draw();        /*    画面作り    */
  1034.     mouse();    /*    メインへ    */
  1035. }
  1036.